Java NIO解析

发表于 | | 阅读次数:

这篇文章先从阻塞与非阻塞，同步与异步之间的定义和关系说起，然后探讨liunx下的5种IO模型，支持非阻塞IO的select/poll/epoll系统调用的基本原理，然后通过Java代码搭建bio方式的服务端，改进服务器在并发场景下bio多线程和线程池的实现方式，最后介绍Java nio来实现一个服务器和多个客户端对话。

阻塞与非阻塞，同步与异步

如果从程序调用来讲，阻塞是指我们执行一个函数调用不能立即得到返回值，而依赖于其他外部的事件完成，比如说网络包的到达、IO操作的完成，否则的话就是非阻塞。其根本原因是cpu执行指令的速度远大于网络操作、IO操作的速度，这种速度差导致了程序运行的阻塞。
同步与异步是从另一个角度来看程序的运行，它是指在程序运行的过程中遇到阻塞事件是否能够让出cpu去处理其他的事情，如果能的话，就是异步的，如果不能的话就是同步的。
从这个角度来看，阻塞与非阻塞，同步与异步是一个事情的两个方面，以IO为对象来说，阻塞IO必然导致着同步，而非阻塞IO也必然导致着异步。

liunx的5种网络IO模型


上图显示了liunx的5种IO模型，其中包括了读的两个执行过程：阶段1）从IO设备读取数据到内核空间(wait for data)和 阶段2）从内核空间复制数据到用户空间(copy data from kernel to user)

  • 阻塞IO,不论是阶段1还是阶段2都是处于阻塞状态
  • 非阻塞IO，不断的检查数据是否准备好，如果没有直接返回一个错误码，第二阶段也是阻塞的
  • IO多路复用，可以看到IO多路复用阶段1和阶段2都是阻塞的，但是不同的是，IO多路复用在阶段1可以同时处理多个文件描述符，这使得在原本用多个线程完成的任务可以在一个线程中完成，但从流程上看，IO多路复用还是阻塞的IO，并且是同步IO。
  • 信号量驱动的IO使用信号来通知数据是否准备好，当数据准备好了才通知线程继续处理，所以阶段1是非阻塞的，但是阶段2仍然是阻塞的过程。
  • 异步IO，异步IO不论是阶段1还是阶段2都是非阻塞的，调用异步IO接口后，函数会立即返回，当数据成功拷贝到用户空间后再通知用户程序继续处理。

从上图看来，前四种IO模型在第2阶段的处理都是一样的，而在第1阶段的处理方式不同。
Java nio的实现是基于IO多路复用实现的，它实现了在同一线程下处理多个文件描述符的功能，这种功能使得应用程序避免了因为线程切换而导致的性能损失。IO多路复用的实现需要系统调用的支持，例如select/poll/epoll,因为本文重点不在这里，所以不详述，可以参考文末的参考文献。

基础BIO Server

从这里开始，我们开始用Java API来写一个server和client通信，以此来探索Java对不同io方式的支持。
首先是最基础的bio，使用ServerSocket API构建一个简单的服务器，基本的过程如下

  • 初始化ServerSocket
  • 绑定ServerSocket到一个InetSocketAddress(ip,port)
  • 调用accept()方法获取客户端socket,这个方法是阻塞的
  • 通过client socket获取对应的inputStream和outputStream读取客户端的信息，并通过outputStream写回信息

主要的代码实现如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
ServerSocket serverSocket=null;
	try {
		serverSocket=new ServerSocket();
		serverSocket.bind(new InetSocketAddress("127.0.0.1", 8888));
		while(true) {
			Socket client=serverSocket.accept();
			client.setSoTimeout(1000);//客户端read要在1秒内返回，不然认为是IO异常
			System.out.println("get connection:"+client);
			InputStream input=client.getInputStream();
			BufferedReader reader=new BufferedReader(new InputStreamReader(input));
			BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
			
			try {
				while(true) {
					String clientWord= reader.readLine();
					client.sendUrgentData(0);//发送心跳包，如果客户端断开连接，则出现IO异常
					if(clientWord==null)
						continue;
					System.out.println(client.getRemoteSocketAddress()+":"+clientWord);
					if("wenqi".equals(clientWord)) {
						writer.write("welcome admin wenqi!\n");
						writer.flush();
					}else {
						writer.write("welcome client "+clientWord+"!\n");
						writer.flush();
					}
				}
			}catch(IOException e) {
				reader.close();
				writer.close();
				client.close();
				System.out.println("断开连接");
			}
		}
	} catch (IOException e) {
		e.printStackTrace();
		
	}

在实际测试的过程中，有一个有趣的问题，如何判断客户端已经断开的连接，不管是正常的，还是不正常的服务端都要正确的处理，在上面的代码我们做的两种处理，一是设置client socket的setSoTimeout(time),这个api的作用是让client的read操作阻塞指定的时间，如果超过指定的时间就抛出SocketException(继承自IOException),强制断开与客户端的连接，这是服务端主动断开连接。
二是在实际情况下，如果客户端断开了连接，服务端并不知道客户端已经断开了连接，并且会一直读到null,这时候服务端在每次读取信息之前就要检查客户端是否还处于连接的状态，我们用sendUrgentData()去判断客户端是否处于连接的状态，如果不是则会抛出IOException，这样，服务端就知道了客户端已经断开了连接，可以关闭连接，不然的话，服务器会一直处于忙等的状态，并且无法处理其他的连接请求。
另外需要注意的是每次用write发送信息的时候必须用\n标注一行信息的结束，并且用flush刷新才会发送过去。
我们在每个客户端的逻辑中连续给服务端发送了两条信息，并且开启了10个线程的客户端，每个客户端主要逻辑如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Socket client=new Socket("127.0.0.1", 8888);
OutputStream out=client.getOutputStream();
InputStream input=client.getInputStream();
BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(out));
BufferedReader reader=new BufferedReader(new InputStreamReader(input));
writer.write("wenqi\n");
writer.flush();
String clientWord=reader.readLine();
System.out.println("server response to "+num+"-"+clientWord);
writer.write("good-"+num+"\n");
writer.flush();
String clientWord2=reader.readLine();
System.out.println("server response to "+num+"-"+clientWord2);
writer.close();
reader.close();
client.close();

基础bio的全部代码可以点击这里

基于线程池的BIO Server

上面的Server可以顺利的处理10个客户端的连接，这得益于我们对服务器和客户端不同状态的正确处理，单从整个过程来看，我们必须串行的逐个处理每个请求，这在并行大行其道的今天，没有让我们用到多处理器并发的优势，在这一节，我们将接受客户端连接放在主线程里，把对每个client socket的读写任务放到每个子线程中去运行，实现这个想法有两种做法：一种是为每个连接开启一个线程，另一种是使用线程池，在少量连接情况的第一种做法是是比较合理的，但是如果在短时间有大量连接的情况下，第二种方案合理，我们使用线程池的方式实现。
在Java中，我们可以通过如下API开启一个固定数目的线程池

1
ExecutorService pool=Executors.newFixedThreadPool(number)

其他的处理逻辑不变,主要逻辑代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
ServerSocket server=null;
		try {
			server=new ServerSocket();
			server.bind(new InetSocketAddress("127.0.0.1", 8888));
			
			while(true) {
				Socket client=server.accept();
				client.setSoTimeout(10000);
				pool.submit(()->{
					try {
						BufferedReader reader=new BufferedReader(new InputStreamReader(client.getInputStream()));
						BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
						try {
							while(true) {
								String clientWord= reader.readLine();
								client.sendUrgentData(0);//发送心跳包，如果客户端断开连接，则出现IO异常
								if(clientWord==null)
									continue;
								System.out.println(client.getRemoteSocketAddress()+":"+clientWord);
								if("wenqi".equals(clientWord)) {
									writer.write("welcome admin wenqi!\n");
									writer.flush();
								}else {
									writer.write("welcome client "+clientWord+"!\n");
									writer.flush();
								}
							}
						}catch(IOException e) {
							System.out.println("断开连接");
						}
						reader.close();
						writer.close();
						client.close();
					}catch(IOException e) {
						e.printStackTrace();
					}
				});
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

基础的NIO Server-Client交互过程

Java的BIO是面向缓冲区和通道的，面向缓冲区的意思是说数据是要写到缓冲区中，然后将缓冲区的数据通过通道出去, 其中最常用的缓冲区是ByteBuffer，它有四个重要属性：

  1. capacity，缓冲区的容量
  2. position，最后一个元素的下一个位置
  3. mark，当position需要变化时存储position
  4. limit，最大能读入或写出的位置

在写入缓冲区后，读取缓冲区需要调用flip()方法，这个方法的作用是将limit=position，将position置为0，然后才可以成功读取。
Channel分为4种：

  1. FileChannel从文件读写数据
  2. DatagramChannel以UDP的形式从网络中读写数据
  3. SocketChannel以TCP的形式从网络中读写数据
  4. ServerSocketChannel可以开启一个非阻塞的ServerSocket

我在这里写了一个简单的例子使用ServerSocketChannel和SocketChannel使用ByteBuffer进行一次对话的例子其主要过程如下：
Server端：

  1. 使用ServerSocketChannel.open()开启一个server
  2. 使用bind方法绑定server到指定的InetSocketAddress
  3. 使用accept()方法获取客户端的SocketChannel
  4. 使用allocate()方法初始化一个ByteBuffer
  5. 使用client SocketChannel读取数据写入到ByteBuffer
  6. byteBuffer flip()之后，读取数据并打印输出

Java代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
ServerSocketChannel server=ServerSocketChannel.open();
server.bind(new InetSocketAddress("127.0.0.1", 8888));
			
SocketChannel client=server.accept();
System.out.println("执行");
ByteBuffer byteBuffer=ByteBuffer.allocate(128);
int size=client.read(byteBuffer);
System.out.println("读取了"+size+"字节");
			
byteBuffer.flip();
String clientworld=new String(byteBuffer.array(),0,size);
System.out.println(clientworld);
server.close();
client.close();

Client端：

  1. 使用SocketChannel.open()开启一个client
  2. 使用connect方法连接对应的InetSocketAddress
  3. 使用allocate()方法初始化一个ByteBuffer
  4. 写入数据后flip()，然后用write方法写入数据

Client端代码如下

1
2
3
4
5
6
7
8
SocketChannel client=SocketChannel.open();
client.connect(new InetSocketAddress("127.0.0.1", 8888));
ByteBuffer writeBuffer=ByteBuffer.allocate(128);
writeBuffer.put("hello world!".getBytes());
writeBuffer.flip();
client.write(writeBuffer);
client.close();

全部代码可以点击这里
值得注意的是，在每次需要从对buffer填充后，需要调用flip()才可以读取buffer中的数据。

单Selector的NIO Server实现

在上面的例子，我们仅仅使用到Socket Channel演示了进行远程通信的一个过程，当然Socket Channel的非阻塞性质并没有显示出来，接下来，我们使用非阻塞Socket来实现一个Client-Server通信。
不论是使用ServerSocketChannel还是SocketChannel都可以通过configureBlocking方法设置为非阻塞Channel,这个方法的意义不仅仅是在执行阻塞方法的时候直接返回，如果我们深入查看，这个方法是来自于ServerSocketChannel和SocketChannel的共同父类SelectableChannel，这个方法更深层次的含义是非阻塞IO和选择性是紧密相关的，实验证明Java必须将Channel设置为非阻塞的才能进行选择。
最后，另外一个重要的类Selector，这个类是实现Java IO多路复用的重要类，它的功能在于两方面：一是非阻塞的Channel可以使用register方法注册感兴趣的阻塞事件，另一方面它可以通过select方法选出已经准备就绪的阻塞事件做进一步的处理。这在多用户连接client-server模式下这种处理方式是很有用的，一方面，每个连接的client连接成功后都可以注册读事件，另一方面服务器可以挑选已经就绪的client进行操作，而不必要仅仅等一个client的读，相比阻塞的Socket处理模式这大大提高了cpu的利用率。
还有一个重要的类SelectionKey,选择好就绪的事件后，selector.selectedKeys()会返回一个就绪的事件集合，根据获取到key，我们可以选择不同的处理方法做进一步的处理。另一个值得注意的问题是在处理完一个key之后注意在key集合中除去它，防止多次处理。单个用户多次发送接受的情况处理用client.read()读取的长度进行判断，如果等于-1，我们就认为客户端断开了。
关于整体的工作示意图如下

从整个图中可以看到Selector在整个过程中具有举足轻重的作用，如果从Reactor模式的角度来看，Selector的select()方法实现了Event Demultiplexer角色的就绪事件的选取，并且和处理注册兴趣事件的Handle角色以及处理事件分发的Dispatcher角色右直接的关联。
以下是我们实现的Java NIO的服务器实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
//开启一个server
ServerSocketChannel server = ServerSocketChannel.open();
server.bind(new InetSocketAddress("127.0.0.1", 8888));
//设置server的accept为非阻塞模式
server.configureBlocking(false);
//设置Selector
Selector selector=Selector.open();
//为server注册selector感兴趣的事件
server.register(selector, SelectionKey.OP_ACCEPT);
//准备好读写的缓冲区
ByteBuffer readBuffer=ByteBuffer.allocate(128);
ByteBuffer writeBuffer=ByteBuffer.allocate(128);
while(true) {
	//阻塞直到有通道被选择
	selector.select();
	Set<SelectionKey> keys=selector.selectedKeys();
	Iterator<SelectionKey>iterator=keys.iterator();
	while(iterator.hasNext()) {
		SelectionKey key=iterator.next();
		//将当前key从selector的中删除,这样在下一次这个key就不会出现
		iterator.remove();
		if(key.isAcceptable()) {
			SocketChannel client=server.accept();
			System.out.println("accept connection from "+client);
			//设置client socket对都不阻塞
			client.configureBlocking(false);
			//将client注册为可读，放入selector
			client.register(selector, SelectionKey.OP_READ);
		}else if(key.isReadable()) {
			SocketChannel client=(SocketChannel) key.channel();
			readBuffer.clear();
			int size=client.read(readBuffer);
			if(size!=-1) {
				readBuffer.flip();//不可少
				String clientWord=new String(readBuffer.array(),0,size);
				//改变key为写信号
				key.interestOps(SelectionKey.OP_WRITE);
				//根据客户传送的信息附带不同的信息
				if("wenqi".equals(clientWord)) {
					key.attach("welcome admin wenqi!");
				}else {
					key.attach("welcome client "+clientWord+"!");
				}
			}else {
				System.out.println("client closed:"+client);
				key.cancel();
				client.close();
			}
		} else if(key.isWritable()) {//isWritable有是否准备好&SelectionKey决定
			SocketChannel client=(SocketChannel) key.channel();
			String backword=(String) key.attachment();
			writeBuffer.clear();
			writeBuffer.put(backword.getBytes());
			writeBuffer.flip();
			client.write(writeBuffer);
			key.interestOps(SelectionKey.OP_READ);
			//不允许多次读写用cancel
			//key.cancel();
		}
	}
}

我们在客户端开启了10个线程模拟10个用户连接，并且每个用户给服务端发送两条不同的信息，以此来测试服务器，全部的代码可以点击这里。
在实现的过程中遇到几个问题，解决后总结如下

  • 当从selector.selectedKeys()中取出一个key处理后，必须将其从集合中删除，不然会重复处理
  • read，write的key删除后在下一轮还是存活，探究许久这个不知所以然，这使得我们可以变更key的interestOps实现多轮读写，但是我们必须在读中判断师傅可读现在，现在的解决方法是通过read的返回值为-1判定客户端断开（-1 if the channel has reached end-of-stream）。

将读写任务分离出去的单Selector服务器实现

虽然我们使用Selector实现了在单线程处理多个请求的功能，但从整个过程来仍然串行的，接受连接，读写数据，每次我们只能执行一项任务，终归到底我们是一个线程，如果读写数据的过程比较长，那么整个服务器就被阻塞在读写任务那里，不能再接受新连接请求，这是我们不愿意看到的。另一方面，多处理器的优势我们没有用到，想到这里，我们很自然的想到将读写任务从主线程解放出来，通过子线程完成读写任务，主线程只关心出来连接，分发读写任务，所以，我们的整个过程变成了下面这样。

因为将读写任务交给了子线程，主线程就可以继续轮询处理其他时间，但是有个问题，正在处理的读写事件并没有从SelectionKeys里面剔除除去，下一次轮询仍然有这个读事件，只不过读出的是空而已。一个解决方法是使用cancel取消key，在完成了写任务后再重新注册key，另一个方法是建立一个在读队列，每次处理key之前看是否在队列中，如果在的话不处理，在完成读写任务后，子线程将现在的key从队列中移除，我采用了第二种方案。
在主线程上，我们做了一下改变

  1. 加入了正在读写队列，在2处进行了逻辑判断
  2. 在3处读操作交给了子线程池处理Worker
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//读写操作处理器
IWorker readProcessor=new Worker();
//进入读写状态的队列
Queue<SelectionKey> operateQueue=new LinkedList<>();//1
while(true) {
	//阻塞直到有通道被选择
	selector.select();
	Set<SelectionKey> keys=selector.selectedKeys();
	Iterator<SelectionKey>iterator=keys.iterator();
	while(iterator.hasNext()) {
		SelectionKey  key=iterator.next();
		//将当前key从selector的中删除,这样在下一次这个key就不会出现
		iterator.remove();
		if(operateQueue.contains(key)) //2
			continue;
		if(key.isAcceptable()) {
			SocketChannel client=server.accept();
			System.out.println("accept connection from "+client.getRemoteAddress());
			//设置client socket对都不阻塞
			client.configureBlocking(false);
			//将client注册为可读，放入selector
			client.register(selector, SelectionKey.OP_READ);
		}else if(key.isReadable()) {
			//分发给Read线程池处理(从内核空间拷贝到用户空间)
			operateQueue.offer(key);
			readProcessor.process(key,operateQueue); //3
		} 
	}
}

Worker的主要逻辑如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
pool.submit(()->{ 
		SocketChannel client=null;
		try {
				ByteBuffer readBuffer=ByteBuffer.allocate(128);
				client=(SocketChannel)key.channel();
				int size=client.read(readBuffer);
				if(size!=-1) {
					readBuffer.flip();
					String clientWord=new String(readBuffer.array(),0,size);
					System.out.println("clientWord:"+clientWord);
					
					if("wenqi".equals(clientWord)) {
						key.attach("welcome admin wenqi!");
						writeProcess(key);
					}else {
						key.attach("welcome client "+clientWord+"!");
						writeProcess(key);
					}
					operateQueue.remove(key);
					
				}else {
					client.close();
					key.cancel();
					System.out.println("client close:"+client);
				}
		
		}catch(IOException e) {
			e.printStackTrace();
			try {
				client.close();
				key.cancel();
				System.out.println("client close:"+client);
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
		}
	});

全部代码请看这里

使用多Selector进一步解放主线程任务

将读写任务分离出去的单Selector服务器实现虽然实现了将读写任务交给了子线程，但是主线程还是要识别并分发read，write时间，那么我们进一步划分任务，让主线程的Selector仅处理accept时间，而将接受到的Client Socket的读写时间交给另一个Selector去处理，岂不更好，说做就做，进一步改进。我们的结构图改成了这样

主要代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
//开启一个server
			ServerSocketChannel server = ServerSocketChannel.open();
			server.bind(new InetSocketAddress("127.0.0.1", 8888));
			//设置server的accept为非阻塞模式
			server.configureBlocking(false);
			
			//设置Selector
			Selector selector=Selector.open();
			//为server注册selector感兴趣的事件
			server.register(selector, SelectionKey.OP_ACCEPT);
			
			//获取多Reactor模式下的子Reactor处理器
			int coreNum=Runtime.getRuntime().availableProcessors();
			System.out.println("得到"+coreNum+"处理器单元");
			Processor[] processors=new Processor[coreNum];
			int index=0;
			for(int i=0;i<coreNum;i++) {
				processors[i]=new Processor();
			}
			
			while(true) {
				//阻塞直到有通道被选择
				selector.select();
				Set<SelectionKey> keys=selector.selectedKeys();
				Iterator<SelectionKey>iterator=keys.iterator();
				while(iterator.hasNext()) {
					SelectionKey  key=iterator.next();
					//将当前key从selector的中删除,这样在下一次这个key就不会出现
					iterator.remove();
					if(key.isAcceptable()) {
						SocketChannel client=server.accept();
						System.out.println("accept connection from "+client.getRemoteAddress());
						//设置client socket对都不阻塞
						client.configureBlocking(false);
						Processor processor=processors[index%coreNum];
						index=(index+1)%coreNum;
						processor.wakeup();
						processor.addChannel(client);
						
					}
				}
			}

子Selector的处理代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
public class Processor {
	
	private ExecutorService pool=Executors.newFixedThreadPool(2*Runtime.getRuntime().availableProcessors());
	private Selector selector;
	public Processor() {
		try {
			selector=SelectorProvider.provider().openSelector();
			process();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	public void  addChannel(SocketChannel client) {
		try {
			//会被select()阻塞掉的
			client.register(selector, SelectionKey.OP_READ);
			//selector.wakeup();
		} catch (ClosedChannelException e) {
			e.printStackTrace();
		}
	}
	
	public void wakeup() {
		selector.wakeup();
	}
	
	private void process() {
		pool.execute(()->{
			while(true) {
					try {
						//使用select()会有一个问题，wakeup后如果继续主线程的register如果没有执行
						//，会进入下一个select阻塞状态，register还是无法执行
						if(selector.select(500)<=0)
							continue;
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					Set<SelectionKey> keys=selector.selectedKeys();
					Iterator<SelectionKey> iterator=keys.iterator();
					while(iterator.hasNext()) {
						SelectionKey key=iterator.next();
						iterator.remove();
						if(key.isReadable()) {
							SocketChannel client=null;
							try {
								ByteBuffer readBuffer=ByteBuffer.allocate(128);
								client=(SocketChannel)key.channel();
								int size=client.read(readBuffer);
								if(size!=-1) {
									readBuffer.flip();
									String clientWord=new String(readBuffer.array(),0,size);
									System.out.println("clientWord:"+clientWord);
									
									if("wenqi".equals(clientWord)) {
										key.attach("welcome admin wenqi!");
										writeProcess(key);
									}else {
										key.attach("welcome client "+clientWord+"!");
										writeProcess(key);
									}
								}else {
									client.close();
									key.cancel();
									System.out.println("client close:"+client);
								}
							}catch(IOException e) {
								try {
									client.close();
									key.cancel();
									System.out.println("client close:"+client);
								}catch(IOException e2) {
									e2.printStackTrace();
								}
							}
						}
					}
			}
		});
	}
	public static void writeProcess(SelectionKey key) {
		try {
			ByteBuffer writeBuffer=ByteBuffer.allocate(128);
			SocketChannel client=(SocketChannel) key.channel();
			String backword=(String) key.attachment();
			System.out.println("writing:"+backword);
			writeBuffer.put(backword.getBytes());
			writeBuffer.flip();
			client.write(writeBuffer);
		}catch(IOException e) {
			e.printStackTrace();
		}
}
}

在实现的过程中，我们使用遇到了一个问题，就是在client.register(selector, SelectionKey.OP_READ);注册Client到子Selector中时出现了死锁，经过多次查找资料，在一个论坛里找到了答案（点击这里，感谢！),原来register方法在select方法阻塞的过程中是也是阻塞的，尽管我们使用wakeup方法使得select方法立即返回，但是也不保证在下一次select方法调用之前执行了register方法，所以最好使用有有效期限的select(time)方法，这样就可以使得正确执行。看来以后遇到问题要先认真看官方文档了。

关于源码

你可以在这里找到本文的所以源码，你同时可以在我的博客看到这篇文章，欢迎批评指正。

参考文档

Java I/O模型从BIO到NIO和Reactor模式
Java并发编程之NIO简明教程
Linux下的五种IO模型
IO多路复用之select、poll、epoll详解
Reactor模式详解

坚持原创技术分享，您的支持将鼓励我继续创作！